package com.teacher.game.state;

import android.graphics.Color;
import android.os.Handler;
import android.os.Looper;
import android.view.MotionEvent;
import com.teacher.ellio.Assets;
import com.teacher.ellio.GameMainActivity;
import com.teacher.game.framework.util.CollisionManager;
import com.teacher.game.framework.util.DebugHUD;
import com.teacher.game.framework.util.Painter;
import com.teacher.game.framework.util.RandomNumberGenerator;
import com.teacher.game.framework.util.ScoreManager;
import com.teacher.game.framework.util.BlockPool;
import com.teacher.game.framework.util.RenderCache;
import com.teacher.game.framework.util.ObstacleManager;
import com.teacher.game.framework.util.ParticleSystem;
import com.teacher.game.framework.util.ParticleEffects;
import com.teacher.game.model.Block;
import com.teacher.game.model.Cloud;
import com.teacher.game.model.Player;
import com.teacher.game.model.PowerUp;
import com.teacher.game.model.AbstractObstacle;

import java.util.ArrayList;

/**
 * 游戏主状态 - 跑酷游戏的核心逻辑
 * 集成玩家控制、碰撞检测、得分系统等所有游戏功能
 */
public class PlayState extends State {

    // 游戏对象
    private Player player;
    private Cloud cloud1, cloud2;
    private ArrayList<Block> blocks; // 保留用于向后兼容
    private ArrayList<PowerUp> powerUps; // 道具系统
    
    // 新障碍物系统
    private ObstacleManager obstacleManager;
    
    // 游戏系统
    private ScoreManager scoreManager;
    private DebugHUD debugHUD; // 调试HUD
    private BlockPool blockPool; // Block对象池
    private RenderCache renderCache; // 渲染缓存系统
    private ParticleSystem particleSystem; // 粒子特效系统
    
    // 游戏状态
    private boolean gameStarted = false;
    private boolean gameOver = false;
    private boolean isPaused = false;
    
    // 游戏参数
    private static final int BASE_BLOCK_SPEED = -200;  // 基础障碍物移动速度
    private static final int INITIAL_BLOCKS = 5;  // 初始障碍物数量
    private static final float BASE_POWERUP_SPAWN_CHANCE = 0.3f; // 基础道具生成概率
    private float powerUpTimer = 0; // 道具生成计时器
    
    // 难度系统
    private int difficulty = DifficultySelectState.DIFFICULTY_NORMAL; // 当前难度
    private int currentBlockSpeed; // 当前障碍物速度
    private float currentPowerUpChance; // 当前道具生成概率
    private int blockSpacing; // 障碍物间距
    
    // 优化：复用临时变量，减少对象创建
    private StringBuilder stringBuilder = new StringBuilder(50); // 复用字符串构建器
    private android.graphics.Rect tempRect = new android.graphics.Rect(); // 复用矩形对象
    
    // 开始提示系统
    private float startHintTimer = 0;
    private static final float START_HINT_DURATION = 3.0f; // 提示显示3秒

    @Override
    public void init() {
        // 初始化游戏对象
        initGameObjects();
        
        // 初始化游戏系统
        initGameSystems();
        
        // 开始播放背景音乐
        Assets.playBgMusic();
    }
    
    /**
     * 初始化游戏对象
     */
    private void initGameObjects() {
        // 初始化玩家
        player = new Player(100, Player.getGroundY());
        
        // 初始化云朵
        cloud1 = new Cloud(100, RandomNumberGenerator.getRandIntBetween(20, 100));
        cloud2 = new Cloud(500, RandomNumberGenerator.getRandIntBetween(20, 100));
        
        // 初始化障碍物（使用对象池优化）
        blocks = new ArrayList<Block>();
        for (int i = 0; i < INITIAL_BLOCKS; i++) {
            Block block = blockPool.acquireBlock(i * blockSpacing + 400, 390);
            blocks.add(block);
        }
        
        // 初始化道具系统
        powerUps = new ArrayList<PowerUp>();
    }
    
    /**
     * 初始化游戏系统
     */
    private void initGameSystems() {
        // 初始化得分系统
        scoreManager = new ScoreManager(GameMainActivity.sGame.getContext());
        
        // 初始化调试HUD
        debugHUD = DebugHUD.getInstance();
        debugHUD.setEnabled(true); // 启用调试模式用于测试
        
        // 初始化Block对象池
        blockPool = BlockPool.getInstance();
        
        // 初始化渲染缓存系统
        renderCache = RenderCache.getInstance();
        
        // 初始化粒子特效系统
        particleSystem = new ParticleSystem(300, 100); // 300个最大活跃粒子，100个池大小
        particleSystem.setEnabled(true);
        
        // 初始化新障碍物管理系统
        obstacleManager = new ObstacleManager();
        
        // 运行障碍物系统测试（调试模式）
        if (debugHUD.isEnabled()) {
            runObstacleSystemTest();
        }
        
        // 配置难度参数
        configureDifficulty();
        
        // 重置游戏状态
        gameStarted = false;
        gameOver = false;
        isPaused = false;
    }
    
    /**
     * 根据难度配置游戏参数
     */
    private void configureDifficulty() {
        switch (difficulty) {
            case DifficultySelectState.DIFFICULTY_EASY:
                currentBlockSpeed = (int)(BASE_BLOCK_SPEED * 0.7f); // 慢30%
                currentPowerUpChance = BASE_POWERUP_SPAWN_CHANCE * 1.5f; // 道具多50%
                blockSpacing = 250; // 大间距
                break;
                
            case DifficultySelectState.DIFFICULTY_NORMAL:
                currentBlockSpeed = BASE_BLOCK_SPEED; // 标准速度
                currentPowerUpChance = BASE_POWERUP_SPAWN_CHANCE; // 标准道具频率
                blockSpacing = 200; // 标准间距
                break;
                
            case DifficultySelectState.DIFFICULTY_HARD:
                currentBlockSpeed = (int)(BASE_BLOCK_SPEED * 1.3f); // 快30%
                currentPowerUpChance = BASE_POWERUP_SPAWN_CHANCE * 0.5f; // 道具少50%
                blockSpacing = 160; // 小间距
                break;
                
            default:
                currentBlockSpeed = BASE_BLOCK_SPEED;
                currentPowerUpChance = BASE_POWERUP_SPAWN_CHANCE;
                blockSpacing = 200;
        }
    }

    @Override
    public void update(float delta) {
        if (gameOver || isPaused) return;
        
        // 更新开始提示计时器
        if (startHintTimer < START_HINT_DURATION) {
            startHintTimer += delta;
        }
        
        // 更新动画
        Assets.runAnim.update(delta);
        
        // 更新粒子系统
        particleSystem.update(delta);
        
        // 更新云朵（始终移动）
        updateClouds(delta);
        
        if (gameStarted) {
            // 游戏开始后更新所有游戏对象
            updateGameplay(delta);
        }
    }
    
    /**
     * 更新云朵
     */
    private void updateClouds(float delta) {
        cloud1.update(delta);
        cloud2.update(delta);
    }
    
    /**
     * 更新游戏玩法相关逻辑
     */
    private void updateGameplay(float delta) {
        // 更新玩家
        player.update(delta);
        
        // 更新得分时间
        scoreManager.updateTime(delta);
        
        // 更新障碍物和检测碰撞（使用新系统）
        updateObstaclesAndCollision(delta);
        
        // 更新道具系统
        updatePowerUps(delta);
        
        // 生成新道具
        updatePowerUpSpawning(delta);
    }
    
    /**
     * 更新障碍物并检测碰撞（新系统版本）
     */
    private void updateObstaclesAndCollision(float delta) {
        // 更新所有障碍物
        obstacleManager.updateAll(delta, currentBlockSpeed);
        
        // 检查玩家越过的障碍物（计分）
        java.util.List<AbstractObstacle> passedObstacles = obstacleManager.checkPassedObstacles(player);
        for (AbstractObstacle obstacle : passedObstacles) {
            // 根据障碍物类型给予不同分数
            int score = obstacle.getRewardScore();
            scoreManager.addScore(score);
            
            // 创建得分特效
            ParticleEffects.createComboScoreEffect(particleSystem, 
                                                 player.getX() + 30, 
                                                 player.getY() - 20, 
                                                 score, 
                                                 scoreManager.getComboCount());
            
            // 播放越过音效
            Assets.playSound(Assets.jumpSoundId);
        }
        
        // 碰撞检测
        AbstractObstacle hitObstacle = obstacleManager.checkCollisions(player);
        if (hitObstacle != null) {
            // 检查护盾保护
            if (player.consumeShield()) {
                // 护盾成功阻挡，播放特殊音效
                Assets.playSound(Assets.jumpSoundId);
                
                // 创建护盾特效
                ParticleEffects.createShieldEffect(particleSystem, 
                                                 player.getX(), 
                                                 player.getY(), 
                                                 player.getWidth());
                
                // 根据障碍物难度给予护盾使用奖励分数
                int shieldBonus = hitObstacle.getDifficultyScore() * 5;
                scoreManager.addBonus(shieldBonus);
            } else {
                // 没有护盾，创建爆炸特效
                ParticleEffects.createMegaExplosionEffect(particleSystem, 
                                                        player.getX(), 
                                                        player.getY());
                
                // 游戏结束
                triggerGameOver();
            }
        }
    }
    
    /**
     * 更新道具系统（优化版本 - 减少对象创建）
     */
    private void updatePowerUps(float delta) {
        // 使用索引遍历，避免创建迭代器对象
        for (int i = powerUps.size() - 1; i >= 0; i--) {
            PowerUp powerUp = powerUps.get(i);
            powerUp.update(delta, currentBlockSpeed); // 使用当前难度的速度
            
            // 检查道具收集
            if (!powerUp.isCollected() && 
                CollisionManager.checkPlayerPowerUpCollision(player, powerUp)) {
                collectPowerUp(powerUp);
            }
            
            // 移除超出屏幕的道具
            if (powerUp.isOffScreen() || powerUp.isCollected()) {
                powerUps.remove(i);
                // 如果有对象池，这里应该回收PowerUp对象
            }
        }
    }
    
    /**
     * 更新道具生成
     */
    private void updatePowerUpSpawning(float delta) {
        powerUpTimer += delta;
        
        // 每3-5秒尝试生成一个道具
        if (powerUpTimer >= RandomNumberGenerator.getRandIntBetween(3, 5)) {
            powerUpTimer = 0;
            
            // 根据当前难度的概率生成道具
            if (Math.random() < currentPowerUpChance) {
                spawnRandomPowerUp();
            }
        }
    }
    
    /**
     * 生成随机道具
     */
    private void spawnRandomPowerUp() {
        // 随机选择道具类型
        int type = RandomNumberGenerator.getRandIntBetween(0, 3); // 0-3对应4种道具类型
        
        // 随机位置（屏幕右侧）
        float x = GameMainActivity.GAME_WIDTH + 50;
        float y = RandomNumberGenerator.getRandIntBetween(200, 320); // 在障碍物高度范围内
        
        powerUps.add(new PowerUp(x, y, type));
    }
    
    /**
     * 收集道具
     */
    private void collectPowerUp(PowerUp powerUp) {
        powerUp.collect();
        
        // 创建道具收集特效
        ParticleEffects.createPowerUpEffect(particleSystem, 
                                          powerUp.getX(), 
                                          powerUp.getY(), 
                                          powerUp.getType());
        
        // 记录道具收集统计
        scoreManager.collectPowerUp();
        
        // 根据道具类型应用效果
        switch (powerUp.getType()) {
            case PowerUp.TYPE_COIN:
                scoreManager.addBonus(powerUp.getValue());
                break;
                
            case PowerUp.TYPE_SHIELD:
                player.activateShield(5.0f); // 5秒护盾
                // 创建护盾充能特效
                ParticleEffects.createShieldChargeEffect(particleSystem, 
                                                       player.getX(), 
                                                       player.getY(), 
                                                       player.getWidth());
                break;
                
            case PowerUp.TYPE_DOUBLE_SCORE:
                player.activateDoubleScore(powerUp.getValue());
                scoreManager.activateDoubleScore(powerUp.getValue());
                // 创建双倍得分特效
                ParticleEffects.createDoubleScoreEffect(particleSystem, 
                                                       player.getX(), 
                                                       player.getY());
                break;
                
            case PowerUp.TYPE_SLOW_TIME:
                player.activateSlowTime(powerUp.getValue());
                // 创建时间减缓特效
                ParticleEffects.createSlowTimeEffect(particleSystem, 
                                                    player.getX(), 
                                                    player.getY());
                break;
        }
        
        // 播放收集音效
        Assets.playSound(Assets.startId);
    }

    @Override
    public void render(Painter g) {
        // 渲染背景
        renderBackground(g);
        
        // 渲染场景元素
        renderSceneElements(g);
        
        // 渲染新障碍物系统
        renderNewObstacles(g);
        
        // 渲染道具
        renderPowerUps(g);
        
        // 渲染玩家
        if (!gameOver) {
            player.render(g);
        }
        
        // 渲染粒子特效（在玩家之后，UI之前）
        particleSystem.render(g);
        
        // 渲染开始提示（如果在显示期间内）
        if (startHintTimer < START_HINT_DURATION) {
            renderStartHint(g);
        }
        
        // 渲染HUD界面
        renderHUD(g);
        
        // 渲染游戏状态提示
        renderGameStateUI(g);
        
        // 渲染调试信息（用于测试优化效果）
        if (debugHUD != null) {
            debugHUD.render(g);
        }
    }
    
    /**
     * 渲染背景
     */
    private void renderBackground(Painter g) {
        g.setColor(Assets.skyBlue);
        g.fillRect(0, 0, GameMainActivity.GAME_WIDTH, GameMainActivity.GAME_HEIGHT);
        g.drawImage(Assets.grass, 0, GameMainActivity.GAME_HEIGHT - Assets.grass.getHeight());
    }
    
    /**
     * 渲染场景元素
     */
    private void renderSceneElements(Painter g) {
        renderSun(g);
        renderClouds(g);
    }
    
    /**
     * 渲染HUD界面（使用缓存优化）
     */
    private void renderHUD(Painter g) {
        if (!gameStarted || gameOver) return;
        
        // 使用渲染缓存优化HUD背景
        String hudBgKey = "hud_background";
        android.graphics.Bitmap hudBackground = renderCache.getCachedElement(
            hudBgKey, 
            GameMainActivity.GAME_WIDTH, 
            70,  // HUD高度
            (canvas) -> {
                android.graphics.Paint paint = new android.graphics.Paint();
                paint.setColor(android.graphics.Color.argb(120, 0, 0, 0));
                canvas.drawRect(0, 0, GameMainActivity.GAME_WIDTH, 70, paint);
            }
        );
        
        // 绘制缓存的HUD背景
        g.drawImage(hudBackground, 0, 0);
        
        // 动态内容（不缓存）
        g.setColor(android.graphics.Color.WHITE);
        g.drawString(scoreManager.getFormattedCurrentScore(), 10, 25);
        g.drawString(scoreManager.getFormattedGameTime(), 600, 25);
        // 障碍物计数（显示新障碍物系统信息）
        g.drawString("障碍物: " + obstacleManager.getDifficultyLevel() + "级", 350, 25);
        
        // 调试信息：粒子系统统计
        if (debugHUD.isEnabled()) {
            g.setColor(android.graphics.Color.CYAN);
            g.drawString("粒子: " + particleSystem.getActiveParticleCount() + "/" + 
                        particleSystem.getMaxParticles(), 350, 45);
        }
        
        // 难度显示
        g.setColor(getDifficultyColor());
        g.drawString("难度: " + DifficultySelectState.getDifficultyName(difficulty), 10, 45);
        
        // 道具效果状态显示
        renderPowerUpEffectsHUD(g);
    }
    
    /**
     * 获取难度颜色
     */
    private int getDifficultyColor() {
        switch (difficulty) {
            case DifficultySelectState.DIFFICULTY_EASY:
                return Color.GREEN;
            case DifficultySelectState.DIFFICULTY_NORMAL:
                return Color.YELLOW;
            case DifficultySelectState.DIFFICULTY_HARD:
                return Color.RED;
            default:
                return Color.WHITE;
        }
    }
    
    /**
     * 渲染道具效果状态HUD
     */
    private void renderPowerUpEffectsHUD(Painter g) {
        int hudX = 10;
        int hudY = 70; // 调整Y坐标避免与HUD重叠
        
        // 护盾状态
        if (player.hasShieldProtection()) {
            g.setColor(Color.BLUE);
            g.drawString("护盾: " + String.format("%.1fs", player.getShieldDuration()), hudX, hudY);
            hudY += 20;
        }
        
        // 双倍得分状态
        if (scoreManager.isDoubleScoreActive()) {
            g.setColor(Color.GREEN);
            g.drawString("双倍得分: " + String.format("%.1fs", scoreManager.getDoubleScoreDuration()), hudX, hudY);
            hudY += 20;
        }
        
        // 时间减缓状态
        if (player.isSlowTimeActive()) {
            g.setColor(Color.MAGENTA);
            g.drawString("时间减缓: " + String.format("%.1fs", player.getSlowTimeDuration()), hudX, hudY);
            hudY += 20;
        }
        
        // 道具收集数量
        if (scoreManager.getPowerUpsCollected() > 0) {
            g.setColor(Color.YELLOW);
            g.drawString("道具: " + scoreManager.getPowerUpsCollected(), hudX, hudY);
        }
    }
    
    /**
     * 渲染游戏状态UI
     */
    private void renderGameStateUI(Painter g) {
        if (!gameStarted) {
            // 游戏开始前的提示
            renderStartInstructions(g);
        } else if (isPaused) {
            // 暂停界面
            renderPauseOverlay(g);
        }
    }
    
    /**
     * 渲染开始说明
     */
    private void renderStartInstructions(Painter g) {
        // 半透明背景
        g.setColor(Color.argb(150, 0, 0, 0));
        g.fillRect(0, 0, GameMainActivity.GAME_WIDTH, GameMainActivity.GAME_HEIGHT);
        
        // 主标题
        g.setColor(Color.WHITE);
        g.drawString("EllioAndroid 跑酷游戏", 300, 150);
        
        // 操作说明
        g.setColor(Color.YELLOW);
        g.drawString("操作说明:", 350, 200);
        g.setColor(Color.WHITE);
        g.drawString("点击屏幕上方: 跳跃", 320, 230);
        g.drawString("点击屏幕下方: 下蹲", 320, 260);
        
        // 开始提示
        g.setColor(Color.CYAN);
        g.drawString("点击任意位置开始游戏", 300, 320);
        
        // 得分规则
        g.setColor(Color.rgb(192, 192, 192)); // LIGHT_GRAY
        g.drawString(scoreManager.getScoringRules(), 50, 350);
    }
    
    /**
     * 渲染暂停覆盖层
     */
    private void renderPauseOverlay(Painter g) {
        g.setColor(Color.argb(180, 0, 0, 0));
        g.fillRect(0, 0, GameMainActivity.GAME_WIDTH, GameMainActivity.GAME_HEIGHT);
        
        g.setColor(Color.WHITE);
        g.drawString("游戏已暂停", 350, 200);
        g.drawString("点击继续游戏", 340, 250);
    }

    /**
     * 渲染新障碍物系统
     */
    private void renderNewObstacles(Painter g) {
        obstacleManager.renderAll(g);
    }
    
    /**
     * 渲染道具
     */
    private void renderPowerUps(Painter g) {
        for (PowerUp powerUp : powerUps) {
            if (!powerUp.isCollected()) {
                powerUp.render(g);
            }
        }
    }

    private void renderClouds(Painter g) {
        g.drawImage(Assets.cloud1, (int) cloud1.getX(), (int) cloud1.getY());
        g.drawImage(Assets.cloud2, (int) cloud2.getX(), (int) cloud2.getY());
    }

    private void renderSun(Painter g) {
        g.setColor(Color.rgb(255, 165, 0));
        int r1 = 85;
        g.fillOval(GameMainActivity.GAME_WIDTH - r1, 0 - r1, 2 * r1, 2 * r1);
        int r2 = 75;
        g.setColor(Color.YELLOW);
        g.fillOval(GameMainActivity.GAME_WIDTH - r2, 0 - r2, 2 * r2, 2 * r2);
    }

    /**
     * 渲染开始提示 - 显示上下半区域标识
     */
    private void renderStartHint(Painter g) {
        // 计算透明度（随时间淡化）
        float alpha = Math.max(0, 1.0f - (startHintTimer / START_HINT_DURATION));
        int alphaValue = (int)(255 * alpha);
        
        // 绘制半透明分隔线
        g.setColor(Color.argb(alphaValue, 255, 255, 0)); // 黄色分隔线
        int midY = GameMainActivity.GAME_HEIGHT / 2;
        for (int i = 0; i < GameMainActivity.GAME_WIDTH; i += 20) {
            g.fillRect(i, midY - 1, 10, 2);
        }
        
        // 绘制区域标识
        g.setColor(Color.argb(alphaValue, 255, 255, 255)); // 白色文字
        
        // 上半区域提示
        g.drawString("↑ 上半区域 ↑", 320, midY - 60);
        g.drawString("点击跳跃越过障碍物", 310, midY - 40);
        
        // 下半区域提示
        g.drawString("↓ 下半区域 ↓", 320, midY + 40);
        g.drawString("点击下蹲避开障碍物", 310, midY + 60);
        
        // 渐变的背景强调
        g.setColor(Color.argb((int)(alphaValue * 0.3f), 0, 0, 0));
        g.fillRect(280, midY - 80, 240, 40); // 上半区域背景
        g.fillRect(280, midY + 20, 240, 60); // 下半区域背景
    }

    @Override
    public boolean onTouch(MotionEvent e, int scaleX, int scaleY) {
        if (e.getAction() == MotionEvent.ACTION_DOWN) {
            return handleTouchDown(scaleX, scaleY);
        }
        return true;
    }
    
    /**
     * 处理触屏按下事件
     */
    private boolean handleTouchDown(int x, int y) {
        if (gameOver) {
            return false; // 游戏结束时不处理触控
        }
        
        if (isPaused) {
            // 暂停状态下，点击恢复游戏
            isPaused = false;
            return true;
        }
        
        if (!gameStarted) {
            // 游戏未开始，点击开始游戏
            startGame();
            return true;
        }
        
        // 游戏进行中，处理玩家操作
        return handlePlayerInput(x, y);
    }
    
    /**
     * 开始游戏
     */
    private void startGame() {
        gameStarted = true;
        Assets.playSound(Assets.startId);
    }
    
    /**
     * 处理玩家输入
     */
    private boolean handlePlayerInput(int x, int y) {
        // 根据点击位置决定动作
        if (y < GameMainActivity.GAME_HEIGHT / 2) {
            // 上半屏幕：跳跃
            player.jump();
            scoreManager.onJump();
            
            // 创建跳跃特效
            ParticleEffects.createEnhancedJumpEffect(particleSystem, 
                                                   player.getX(), 
                                                   player.getY() + player.getHeight());
        } else {
            // 下半屏幕：下蹲
            player.duck();
            scoreManager.onDuck();
            
            // 创建下蹲滑行特效
            ParticleEffects.createDuckSlideEffect(particleSystem, 
                                                player.getX(), 
                                                player.getY() + player.getHeight());
        }
        return true;
    }
    
    /**
     * 触发游戏结束
     */
    private void triggerGameOver() {
        if (gameOver) return; // 防止重复触发
        
        gameOver = true;
        scoreManager.gameOver();
        
        // 播放碰撞音效
        Assets.playSound(Assets.hitSoundId);
        
        // 延迟跳转到游戏结束页面，使用主线程Handler确保线程安全
        new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
            @Override
            public void run() {
                try {
                    setCurrState(new GameOverState(scoreManager));
                } catch (Exception e) {
                    // 如果状态切换失败，返回主菜单
                    setCurrState(new MenuState());
                }
            }
        }, 1500); // 1.5秒延迟，让玩家看到碰撞效果
    }
    
    /**
     * 暂停游戏
     */
    public void pauseGame() {
        isPaused = true;
    }
    
    /**
     * 恢复游戏
     */
    public void resumeGame() {
        isPaused = false;
    }
    
    /**
     * 获取当前得分
     */
    public int getCurrentScore() {
        return scoreManager != null ? scoreManager.getCurrentScore() : 0;
    }
    
    /**
     * 检查游戏是否已开始
     */
    public boolean isGameStarted() {
        return gameStarted;
    }
    
    /**
     * 检查游戏是否结束
     */
    public boolean isGameOver() {
        return gameOver;
    }
    
    /**
     * 设置游戏难度
     * @param difficulty 难度等级
     */
    public void setDifficulty(int difficulty) {
        this.difficulty = difficulty;
    }
    
    /**
     * 获取当前游戏难度
     */
    public int getDifficulty() {
        return difficulty;
    }
    
    /**
     * 运行障碍物系统测试（调试用）
     */
    private void runObstacleSystemTest() {
        try {
            // 动态运行测试
            android.util.Log.d("PlayState", "开始障碍物系统验证...");
            
            // 简单验证障碍物管理器功能
            if (obstacleManager != null) {
                android.util.Log.d("PlayState", "障碍物管理器初始化成功");
                android.util.Log.d("PlayState", "初始统计: " + obstacleManager.getStatistics());
            }
            
        } catch (Exception e) {
            android.util.Log.e("PlayState", "障碍物系统测试失败", e);
        }
    }
}
